﻿//#define _CRT_SECURE_NO_WARNINGS 1
//C++第一个程序

//c++兼容C语言
//c语言的写法
//#include<stdio.h>
//
//int main()
//{
//	printf("hello world\n");
//	return 0;
//}

//C++版本标准的hello world
//#include<iostream>
//using namespace std;
//
//int main()
//{
//	cout << "hello world\n" << endl;
//	return 0;
//}






//namespace(命名空间）

//namespace解决了C语言命名冲突的问题，比如说在公司，大家都是分工合作，然后再将代码汇聚在一起，这个时候，张三和李四定义变量，或者别的，都选用了同一个名字，会发生命名冲突，为解决这个问题，命名空间可
//单独开创一个域，而不同的域可定义同名变量。

//#include<stdio.h>
//#include<stdlib.h>//C语言stdlib头文件包含rand函数
//
//int rand = 10;
//
//int main()
//{
//	printf("%d", rand);
//	return 0;
//}

//错误	C2365	“rand” : 重定义；
//因为C语言中已有rand函数，不可再定义同名rand;
//为解决这个问题，namespace可单独创建一个域，定义rand

//#include<stdio.h>
//#include<stdlib.h>
//
////namespace的用法
////namespace关键字，后面跟命名空间的名字，然后接一对{}，{}中即为命名空间的成员。namespace可以定义变量/函数/类型等。
//namespace cyy
//{
//	int rand = 10;
//}
//
//int main()
//{
//	printf("%p\n", rand);//此rand因为全局变量的rand，非namespace域中的rand
//	//如何访问命名空间里面的rand?
//	// :: 域作用限定符  （::左边什么都不写，默认全局）
//	printf("%d", cyy::rand);
//	return 0;
//}

//namespace可以定义变量/函数/类型等。
//#include<stdio.h>
//
//namespace cyy
//{
//	int rand = 10;
//
//	int Add(int left, int right)
//	{
//		return left + right;
//	}
//
//	struct Node
//	{
//		struct Node* next;
//		int val;
//	};
//}
//
//
//int main()
//{
//	printf("%d", cyy::rand);
//	printf("%d", cyy::Add(1, 1));
//	//注意结构部分
//	struct cyy::Node p1;
//	return 0;
//}

//namespace可以嵌套定义
//比如，公司里面两三个人写一个项目的部分，分为多组，本身一个大项目就会有一个namespace，航哥和鹏哥在一个组，也要定义命名空间
//#include<stdio.h>
//
//namespace bit
//{
//	namespace pg
//	{
//		int a = 4;
//	}
//	namespace hg
//	{
//		int a = 8;
//	}
//}
//using namespace bit;
//using bit::pg::a;
//int main()
//{
//	printf("%d\n", bit::pg::a);
//	return 0;
//}

//每次指定命名空间都很麻烦，可以展开命名空间
//1.using namespace bit;(全部）
//2.using bit::pg::a;（展开常用的）

//C++第一个程序

//c++兼容C语言
//c语言的写法
//#include<stdio.h>
//
//int main()
//{
//	printf("hello world\n");
//	return 0;
//}

//C++版本标准的hello world
//#include<iostream>
//using namespace std;
//
//int main()
//{
//	cout << "hello world\n" << endl;
//	return 0;
//}






//namespace(命名空间）

//namespace解决了C语言命名冲突的问题，比如说在公司，大家都是分工合作，然后再将代码汇聚在一起，这个时候，张三和李四定义变量，或者别的，都选用了同一个名字，会发生命名冲突，为解决这个问题，命名空间可
//单独开创一个域，而不同的域可定义同名变量。

//#include<stdio.h>
//#include<stdlib.h>//C语言stdlib头文件包含rand函数
//
//int rand = 10;
//
//int main()
//{
//	printf("%d", rand);
//	return 0;
//}

//错误	C2365	“rand” : 重定义；
//因为C语言中已有rand函数，不可再定义同名rand;
//为解决这个问题，namespace可单独创建一个域，定义rand

//#include<stdio.h>
//#include<stdlib.h>
//
////namespace的用法
////namespace关键字，后面跟命名空间的名字，然后接一对{}，{}中即为命名空间的成员。namespace可以定义变量/函数/类型等。
//namespace cyy
//{
//	int rand = 10;
//}
//
//int main()
//{
//	printf("%p\n", rand);//此rand因为全局变量的rand，非namespace域中的rand
//	//如何访问命名空间里面的rand?
//	// :: 域作用限定符  （::左边什么都不写，默认全局）
//	printf("%d", cyy::rand);
//	return 0;
//}

//namespace可以定义变量/函数/类型等。
//#include<stdio.h>
//
//namespace cyy
//{
//	int rand = 10;
//
//	int Add(int left, int right)
//	{
//		return left + right;
//	}
//
//	struct Node
//	{
//		struct Node* next;
//		int val;
//	};
//}
//
//
//int main()
//{
//	printf("%d", cyy::rand);
//	printf("%d", cyy::Add(1, 1));
//	//注意结构部分
//	struct cyy::Node p1;
//	return 0;
//}

//namespace可以嵌套定义
//比如，公司里面两三个人写一个项目的部分，分为多组，本身一个大项目就会有一个namespace，航哥和鹏哥在一个组，也要定义命名空间
//#include<stdio.h>
//
//namespace bit
//{
//	namespace pg
//	{
//		int a = 4;
//	}
//	namespace hg
//	{
//		int a = 8;
//	}
//}
//using namespace bit;
//using bit::pg::a;
//int main()
//{
//	printf("%d\n", bit::pg::a);
//	return 0;
//}

//每次指定命名空间都很麻烦，可以展开命名空间
//1.using namespace bit;(全部）
//2.using bit::pg::a;（展开常用的）



//C++第一个程序

//c++兼容C语言
//c语言的写法
//#include<stdio.h>
//
//int main()
//{
//	printf("hello world\n");
//	return 0;
//}

//C++版本标准的hello world
//#include<iostream>
//using namespace std;
//
//int main()
//{
//	cout << "hello world\n" << endl;
//	return 0;
//}






//namespace(命名空间）

//namespace解决了C语言命名冲突的问题，比如说在公司，大家都是分工合作，然后再将代码汇聚在一起，这个时候，张三和李四定义变量，或者别的，都选用了同一个名字，会发生命名冲突，为解决这个问题，命名空间可
//单独开创一个域，而不同的域可定义同名变量。

//#include<stdio.h>
//#include<stdlib.h>//C语言stdlib头文件包含rand函数
//
//int rand = 10;
//
//int main()
//{
//	printf("%d", rand);
//	return 0;
//}

//错误	C2365	“rand” : 重定义；
//因为C语言中已有rand函数，不可再定义同名rand;
//为解决这个问题，namespace可单独创建一个域，定义rand

//#include<stdio.h>
//#include<stdlib.h>
//
////namespace的用法
////namespace关键字，后面跟命名空间的名字，然后接一对{}，{}中即为命名空间的成员。namespace可以定义变量/函数/类型等。
//namespace cyy
//{
//	int rand = 10;
//}
//
//int main()
//{
//	printf("%p\n", rand);//此rand因为全局变量的rand，非namespace域中的rand
//	//如何访问命名空间里面的rand?
//	// :: 域作用限定符  （::左边什么都不写，默认全局）
//	printf("%d", cyy::rand);
//	return 0;
//}

//namespace可以定义变量/函数/类型等。
//#include<stdio.h>
//
//namespace cyy
//{
//	int rand = 10;
//
//	int Add(int left, int right)
//	{
//		return left + right;
//	}
//
//	struct Node
//	{
//		struct Node* next;
//		int val;
//	};
//}
//
//
//int main()
//{
//	printf("%d", cyy::rand);
//	printf("%d", cyy::Add(1, 1));
//	//注意结构部分
//	struct cyy::Node p1;
//	return 0;
//}

//namespace可以嵌套定义
//比如，公司里面两三个人写一个项目的部分，分为多组，本身一个大项目就会有一个namespace，航哥和鹏哥在一个组，也要定义命名空间
//#include<stdio.h>
//
//namespace bit
//{
//	namespace pg
//	{
//		int a = 4;
//	}
//	namespace hg
//	{
//		int a = 8;
//	}
//}
//using namespace bit;
//using bit::pg::a;
//int main()
//{
//	printf("%d\n", bit::pg::a);
//	return 0;
//}

//每次指定命名空间都很麻烦，可以展开命名空间
//1.using namespace bit;(全部）
//2.using bit::pg::a;（展开常用的）


//类的默认成员函数
//构造函数(初始化）
//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	//无参构造函数，全缺省构造函数，我们不写编译器会自动生成的构造函数，都为默认构造函数
//	//这三个函数有且只有一个存在，不能同时存在
//	//默认构造：不传实参就可以调用的构造
//	//我们不写编译器会自动生成的构造函数：对内置类型成员变量的初始化没有要求，看编译器，对自定义泪下成员变量，要求调用这个成员变量的默认构造初始化。如果这个自定义类型没有默认构造，编译器会报错。
//
//
//
//	//无参构造函数
//	Date()//1.函数名与类名相同，没有返回值，会自动调用
//	{     //2.构造函数可以重载
//		_year = 1;
//		_month = 1;
//		_day = 1;
//	 }
//	//2.带参构造函数
//	Date(int year, int month, int day)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	////3全缺省构造函数
//	//Date(int year = 2, int month =3, int day =4)
//	//{
//	//	_year = year;
//	//	_month = month;
//	//	_day = day;
	//}
//	void Print()
//	{
//		cout << _year <<"/" << _month << "/" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//int main()
//{
//	Date d1;
//	//无参不能这样写
//	//Date d1();
//	d1.Print();//不需要显示调用，会自动调用
//
//	Date d2(2020, 3, 3);
//	d2.Print();
//
//	Date d3;
//	return 0;
//}

//总结：大多数情况下，构造函数都需要自己写，上述情况类似MyQueue且Stack有默认构造时，MyQueue自动生成可以用。



//析构函数（完成对象中的资源清理工作）
//析构函数特点:
//1.析构函数是在类名前加上字符~。
//2.无参数，无返回值
//3.一个类有且只有一个析构函数
//4.对象生命周期结束时，系统会自动调用析构函数
//5.自定义类型成员会自动调用析构函数
//#include<iostream>
//using namespace std;
//typedef int STDataType;
//
//class Stack
//{
//public:
//	Stack(int n = 4)
//	{
//		_a = (STDataType*)malloc(sizeof(STDataType) * n);
//		if (nullptr == _a)
//		{
//			perror("malloc申请空间失败");
//				return;
//		}
//		_capacity = n;
//		_top = 0;
//	}
//	//析构函数
//	~Stack()
//	{
//		free(_a);
//		_a = nullptr;
//		_top = _capacity = 0;
//	}
//private:
//	STDataType* _a;
//	size_t _capacity;
//	size_t _top;
//};
//
//int main()
//{
//	
//	Stack st1;
//	Stack st2;//后定义的先析构
//	return 0;
//}





//运算符重载（用于自定义类型比较大小）
//由operator关键字+要定义的运算符构成
// 有五个运算符不能重载:   .*  :: sizeof  ?:   .
//.*
//#include<iostream>
//using namespace std;
//
//class A
//{
//public:
//	void func()
//	{
//		cout << "A::func()" << endl;
//	}
//};
//typedef void(A::* PF)();
//
//int main()
//{
//	PF pf = nullptr;
//	
//	//c++规定成员函数要加&才能取到函数指针
//	pf = &A::func;
//
//	A aa;
//	(aa.*pf)();//回调成员函数用.*(了解）
//}




//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	
//	//尽量用全缺省构造函数（虽然不知道为什么）
//	Date(int year = 2, int month =3, int day =4)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year <<"/" << _month << "/" << _day << endl;
//	}
//	
//	bool operator==( Date d2)
//	{
//		return _year == d2._year
//			&& _month == d2._month//如何解决私有成员变量可以被访问呢？
//			&& _day == d2._day;   //提供Get函数
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
////运算符重载
//bool operator<(Date d1, Date d2)
//{
//	
//}
//
////bool operator==(Date d1,Date d2)
////{
////	return d1._year == d2._year
////		&& d1._month == d2._month//如何解决私有成员变量可以被访问呢？
////		&& d1._day == d2._day;   //C++中一般不愿意把成员变量放在公有，因为可能会被修改，所以要把它放进类域里面，但是不要忘记了隐藏的this指针，所以第一个参数要省略
////}
////对比（注意：这只是在类域里面）
////bool operator==(Date d2)
////{
////	return _year == d2._year
////		&& _month == d2._month//如何解决私有成员变量可以被访问呢？
////		&& _day == d2._day;   //提供Get函数
////}
//
//
//int main()
//{
//	Date d1(2024, 6, 23);
//	Date d2(2024,6,24);
//	
//	//operator==(d1,d2);//错误写法
//	//正确写法
//	d1.operator==(d2);
//	d1 == d2;//两者具有同等效应
//
//	return 0;
//}
//

//赋值运算符重载
//特点：必须重载为成员函数



//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	
//	
//	Date(int year = 2, int month =3, int day =4)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	void Print()
//	{
//		cout << _year <<"/" << _month << "/" << _day << endl;
//	}
//	
//	bool operator==( Date d2)
//	{
//		return _year == d2._year
//			&& _month == d2._month
//			&& _day == d2._day;   
//	}
//
//	//d1 = d2;
//	Date& operator=(const Date& d)
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//		return *this;//赋值的传参和传返回值都是建议用引用，可以减少拷贝（C++规定传值传参都是拷贝构造），提高效率
//	}
//
//	//d1+100;
//	Date operator+(int day);
//	//d1-100;
//	Date operator-(int day);
//	//d1-d2;
//	int operator-(const Date& d);
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//
//
//
//
//
//int main()
//{
//	Date d1(2024, 6, 23);
//	Date d2(2024,6,24);
//	//赋值重载拷贝(两个已经存在的对象直接的拷贝赋值）
//	d1 = d2;
//	
//	//拷贝构造（用于一个对象拷贝初始化给另一个要创建的对象）
//	Date d3(d2);
//	Date d4 = d2;//d4不存在，拿d2去初始化了一个对象，是拷贝构造（已经开始混了）
//
//
//
//	return 0;
//}
//显示实现析构并释放资源，那么就要写拷贝构造和赋值重载




//拷贝构造函数(如果第一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫拷贝构造函数，拷贝构造是一个特殊的构造函数
//拷贝构造函数的特点：
// 2. 拷贝构造的第一个参数必须是自身类类型的引用，使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发⽆穷递归调⽤。
//3. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返
//回都会调⽤拷⻉构造完成。
//4. 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成
//员变量会完成值拷⻉ / 浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构
//造。
//5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完
//成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。
// 像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉ / 浅拷⻉不符合我们的需求，所以需要
//我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。
// 像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现
//MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就
//需要显⽰写拷⻉构造，否则就不需要。
//#include<iostream>
//using namespace std;
//class Date
//{
//public:
//	Date(int year = 1, int month = 1, int day = 1)
//	{
//		_year = year;
//		_month = month;
//		_day = day;
//	}
//	Date(const Date& d)//传引用，如果不想改变形参，加const准没错	
//	{
//		_year = d._year;
//		_month = d._month;
//		_day = d._day;
//	}
//	void Print()
//	{
//		cout << _year << "-" << _month << "-" << _day << endl;
//	}
//private:
//	int _year;
//	int _month;
//	int _day;
//};
//void Func1(Date d)
//{
//	cout << &d << endl;
//	d.Print();
//}


//int main()
//{
//	
//	Date d1(2024, 5, 27);
//	//C++规定，函数的传值传参要调用拷贝构造   
//	Func1(d1);
//	d1.Print();
//
//	//拷贝构造
//	Date d2(d1);
//	d2.Print();
//	return 0;
//}






////类型转换
#include<iostream>
using namespace std;
//class A
//{
//public:
//	A(int a)
//		:_a1(a)
//	{
//
//	}
//	void print()
//	{
//		cout << _a1 << "" << _a2 << endl;
//	}
//private:
//	int _a1;
//	int _a2;
//};
////意义：
//class Stack
//{
//public:
//	void Push(const A& aa)
//	{
//		//
//	}
//private:
//
//	A _arr[10];
//	int _top;
//};
//int main()
//{
//	A aa1(1);//调用构造函数
//	aa1.print();
//
//
//	//隐式类型转换
//	A aa2 = 2;//2构造A的临时对象，再用这个临时对象拷贝构造aa2   //编译器遇到连续构造+拷贝构造—>优化为直接构造
//	aa2.print();
//
//
//	A aa3(3);//A段
//	Stack st;
//	st.Push(aa3);
//
//	st.Push(3);//B段 （写起来更简单）
//	return 0;
//}
// 
// 
// 
//




//再探构造函数（初始化列表）——构造函数初始化的一种
//尽量使用初始化列表

//初始化列表总结：
//1.在初始化列表初始化的成员
//2.没有在初始化列表的成员
//  a.声明的地方有缺省值用缺省值
//  b.没有缺省值
//	x:内置类型，不确定，看编译器，大概率是随机值
//	y:自定义类型，调用默认构造，没有默认构造，编译器会报错
//3.引用成员，const成员必须在初始化列表初始化


//class Time
//{
//public:
//	Time(int hour = 0)
//		:_hour(hour)
//	{
//		cout << "Time()" << endl;
//	}
//private:
//	int _hour;
//};
//
//class Date
//{
//public:
//	
//	//初始化列表(只能初始化一次）
//	Date(int &xx,int year, int month, int day)
//		:_year(year)
//		,_month(month)
//		,_day(day)
//		,_n(1)
//		,_ref(xx)
//		,_t(1)
//	{}
//
//
//
//	void Print()
//	{
//		cout << _year << " " << _month << " " << _day << endl;
//
//	}
//private:
//	////声明
//	//int _year;
//	//int _month;
//	//int _day;
//
//
//	////const成员,引用成员必须在初始化列表初始化
//	//int& _ref;
//	//const int  _n;
//	////没有默认构造函数可用
//	//Time _t;
//
//
//	//C++ 11（缺省值）
//	int _year = 1 ;
//	int _month = 3;
//	int _day = 4;
//	const int  _n = 4;
//	Time _t = 1;
//	
//
//	
//	
//
//};
//int main()
//{
//	//对象定义                                                                                                                                                                                                                    
//	int x;
//	Date d1(x,2024, 2, 25);
//	d1.Print();
//	return 0;
//}

//题目

//初始化列表是按声明的顺序初始化的
//class A
//{
//public:
//	A(int a)
//		:_a1(a)
//		, _a2(_a1)//a1初始化a2,是随机值，再用a初始化a1
//	{}
//	void Print() {
//		cout << _a1 << " " << _a2 << endl;
//	}
//private:
//	int _a2 = 2;
//	int _a1 = 2;
//};
//int main()
//{
//	A aa(1);
//	aa.Print();
//}
//


//static成员（静态成员）
//静态成员变量一定要在类外进行初始化
//静态成员变量为所有类对象所共享，存放在静态区
//公有情况下，突破类域就可以访问静态成员  1.类：：静态成员   2.对象.静态成员
//访问私有的静态成员，用静态成员函数
//	//静态成员函数（没有this指针）,静态成员函数只能访问静态成员，不能访问非静态成员
//	//非静态可以随便访问静态

//class  A
//{
//public:
//	A()
//	{
//		++_scount;
//	}
//	A(const A& t)
//	{
//		++_scount;
//	}
//
//	~A()
//	{
//		--_scount;
//	}
//	//静态成员函数（没有this指针）,静态成员函数只能访问静态成员，不能访问非静态成员
//	static int GetACount()
//	{
//		return _scount;
//	}
//	//非静态可以随便访问静态
//	void Fun()
//	{
//		 _scount;
//	}
//private:
//	//类里面声明
//	static int _scount;//不可给缺省值
//};
////类外面初始化
//int A::_scount = 0;
//int main()
//{
//	//访问私有的静态成员，用静态成员函数
//
//	A a1, a2;
//	//局部域，出了这个域，a3就销毁了
//	{
//		A a3(a1);
//
//	}
//	cout << A::GetACount() << endl;
//	cout << a1.GetACount() << endl;
//	
//	return 0;
//
//}

//友元
//友元分为友元函数和友元类
//友元函数可访问类的私有和保护成员，友元函数仅仅是一个声明
//一个函数可以成为多个类的友元

//前置声明，A的友元函数声明编译器不认识B
//class B;
//class A
//{
//public:
//	friend void func(const A& aa, const B& bb);
//private:
//	int _a1 = 1;
//	int _a2 = 2;
//};
//class B
//{
//public:
//	friend void func(const A& aa, const B& bb);
//private:
//	int _b1 = 3;
//	int _b2 = 4;
//};
//
//void func(const A& aa, const B & bb)
//{
//	cout << aa._a1 << endl;
//	cout << bb._b1 << endl;
//}
//int main()
//{
//	A aa;
//	B bb;
//	func(aa, bb);
//	return 0;
//}


//友元类(友元类中的成员函数都可以是另一个类的友元函数，都可以访问另一个类中的私有和保护成员。）
//友元类的关系是单相的，不具有交换性，比如A是B的友元，但B不是A的友元
//友元不能传递，比如A是B的友元，A是C的友元,A不是C的友元
//class A
//{
//	//友元类(友元声明）
//	friend class B;
//private:
//	int _a1 = 1;
//	int _a2 = 2;
//};
//
//class B
//{
//public:
//	void func1(const A& aa)
//	{
//		cout << aa._a1 << endl;
//		cout << _b1 << endl;
//	}
//	void func2(const A& aa)
//	{
//		cout << aa._a2 << endl;
//		cout << _b2 << endl;
//	}
//private:
//	int _b1 = 3;
//	int _b2 = 4;
//};
////友元不宜多用



//内部类
// 内部类默认是外部类的友元
//B受A类域的限制，
//class A
//{
//private:
//	static int _k;
//	int _h = 1;
//public:
//	class B//B默认是A的友元
//	{
//	public:
//		void foo(const A& a)
//		{
//			cout << _k << endl;
//		//	cout << a._h << endl;
//		}
//	private:
//		int _b = 1;
//	};
//	
//
//};
//
//int main()
//{
//
//	//访问B中的元素
//	A::B _b;
//	return 0;
//}

//匿名对象

//class A
//{
//public:
//	A(int a = 0)
//		:_a(a)
//	{
//		cout << "A(int a)" << endl;
//	}
//	~A()
//	{
//		cout << "~A()" << endl;
//	}
//private:
//	int _a;
//};
//class Solution
//{
//public:
//	int Sum_Solution(int n)
//	{
//		return n;
//	}
//};
//
//int main()
//{
//	A aa1;//有名对象
//
//	//不能这样定义，因为编译器无法识别下面一个函数声明，还是对象定义
//	A aa1();
//
//	//生命周期只在当前这一行
//	A();//匿名对象
//	A(1);
//
//	Solution st;
//	cout << st.Sum_Solution(10) << endl;//有名对象
//
//	cout << Solution().Sum_Solution(10) << endl;//有名对象
//
//	int a[] = { 1,3,5,4,2,8,9 };
//	return 0;
//}
//


class test
{
public:
	static int get()
	{
		cout << _a;
		return _a;
	}
private:
	static int _a;
};
int test::_a = 0;
int main()
{
	test st;
	st.get();
	return 0;
}

